home *** CD-ROM | disk | FTP | other *** search
/ Celestin Apprentice 2 / Apprentice-Release2.iso / Tools / Languages / MacGofer 0.22d / MacGofer Sources / mac_prefs.c < prev    next >
Encoding:
C/C++ Source or Header  |  1994-01-06  |  8.1 KB  |  377 lines  |  [TEXT/MPS ]
  1. /*****************************************************************************
  2.  
  3.   mac_prefs.c:  Copyright (c) Kevin Hammond 1993.   All rights reserved.
  4.   
  5.   Preference file handling
  6.  
  7. *****************************************************************************/
  8.  
  9. #include "mac.h"
  10.  
  11. #pragma segment Prefs
  12.  
  13. extern short  preludevolref;        /* vrefnum for the Prelude              */
  14. extern long   preludedirID;        /* HFS dirid for the Prelude            */
  15. extern maxEvidLevel, HeapPC;            /* Evidence level and heap % settings   */
  16. extern OSType preftype;            /* Type of preference files             */
  17.  
  18. extern char *PreludeName, *safemalloc();
  19.  
  20. extern Boolean checkFileExists();
  21.  
  22. Boolean HiddenPrefsChanged = FALSE;
  23. char *PrefsName;
  24. static short prefsvolref;
  25. static long prefsdirID;
  26. static Boolean prefsvolset = FALSE;
  27.  
  28.  
  29. /*
  30.     Structures defining legal types of preference:
  31.     Int, Bool, String.
  32.     
  33.     The distinction between "set" and "save" values is needed if
  34.     we are to save new settings without changing the current
  35.     settings.  This is necessary for the num_ settings which are
  36.     used to define buffer sizes.
  37. */
  38.  
  39.  
  40. struct Prefs
  41. {
  42.   int *setvalue;    /* Value to set on startup */
  43.   int *savevalue;    /* Value to save to file */
  44.   char *tag;
  45. };
  46.  
  47. struct BPrefs
  48. {
  49.   int *value;
  50.   char *tag;
  51.   Boolean HiddenPref;
  52. };
  53.  
  54.  
  55. struct SPrefs
  56. {
  57.   char **value;
  58.   char *tag;
  59. };
  60.  
  61.  
  62. /*
  63.     Numeric Preferences and their tags in the Preferences file.
  64. */
  65.  
  66. static struct Prefs Prefs[] =
  67. {
  68.   {&maxEvidLevel,    &maxEvidLevel,    "ED"},
  69.   {&HeapPC,        &HeapPC,    "HP"},
  70.   {&num_stack,        &Num_stack,    "NS"},
  71.   {&num_name,        &Num_name,    "NN"},
  72.   {&num_classes,    &Num_classes,    "NC"},
  73.   {&num_insts,        &Num_insts,    "NI"},
  74.   {&num_tycon,        &Num_tycon,    "NT"},
  75.   {&num_tyvars,        &Num_tyvars,    "NV"},
  76.   {&num_addrs,        &Num_addrs,    "NA"},
  77.   {&num_offsets,    &Num_offsets,    "NO"},
  78.   {&num_files,        &Num_files,    "NF"},
  79.   {&num_modules,    &Num_modules,    "NM"},
  80.   {&num_tuples,        &Num_tuples,    "NP"},
  81.   {&num_fixups,        &Num_fixups,    "NU"},
  82.   {&num_indexes,    &Num_indexes,    "NX"},
  83.   {&num_syntax,        &Num_syntax,    "NY"},
  84.   {&num_text,        &Num_text,    "NZ"},
  85.   {&num_selects,    &Num_selects,    "NL"}
  86. };
  87.  
  88.  
  89. /*
  90.     Boolean Preferences,their tags in the Preferences file
  91.     and their default value.
  92.     
  93.     Think C needs (int *) coercions.
  94. */
  95.  
  96.  
  97. #if !THINKC
  98. static struct BPrefs BPrefs[] =
  99. {
  100.   {&showStats,        "ST",    TRUE},
  101.   {&gcMessages,        "GC",    FALSE},
  102.   {&addType,        "ET",    FALSE},
  103.   {&literateScripts,    "LI",    FALSE},
  104.   {&coerceNumLiterals,    "HN",    FALSE},
  105.   {&showDicts,        "SD",    FALSE},
  106.   {&traceEval,        "TR",    FALSE},
  107.   {&literateErrors,    "LE",    TRUE},
  108.   {&AutoLoad,        "AL",    TRUE},
  109.   {&MultiTasking,    "MT",    FALSE},
  110.   {&anyEvidence,    "EA",    TRUE},
  111.   {&silentEvFail,    "ES",    TRUE},
  112.   {&andorOptimise,    "OB",    TRUE},
  113.   {&failOnError,    "FE",    TRUE},
  114.   {&catchAmbigs,    "TA",    FALSE},
  115.   {&useConformality,    "PC",    TRUE},
  116.   {&kindExpert,        "KE",    FALSE},
  117.   {&overSingleton,    "OS",    TRUE}
  118. };
  119.  
  120. #else
  121.  
  122. static struct BPrefs BPrefs[] =
  123. {
  124.   {(int *) &showStats,        "ST",    FALSE},
  125.   {(int *) &gcMessages,        "GC",    FALSE},
  126.   {(int *) &addType,        "ET",    FALSE},
  127.   {(int *) &literateScripts,    "LI",    FALSE},
  128.   {(int *) &coerceNumLiterals,    "HN",    FALSE},
  129.   {(int *) &showDicts,        "SD",    FALSE},
  130.   {(int *) &traceEval,        "TR",    FALSE},
  131.   {(int *) &literateErrors,    "LE",    FALSE},
  132.   {(int *) &AutoLoad,        "AL",    FALSE},
  133.   {(int *) &MultiTasking,    "MT",    FALSE},
  134.   {(int *) &anyEvidence,    "EA",    TRUE},
  135.   {(int *) &silentEvFail,    "ES",    TRUE},
  136.   {(int *) &andorOptimise,    "OB",    TRUE},
  137.   {(int *) &failOnError,    "FE",    TRUE},
  138.   {(int *) &catchAmbigs,    "TA",    FALSE},
  139.   {(int *) &useConformality,    "PC",    TRUE},
  140.   {(int *) &kindExpert,        "KE",    FALSE},
  141.   {(int *) &overSingleton,    "OS",    TRUE}
  142. };
  143. #endif
  144.  
  145. /*
  146. static struct SPrefs SPrefs[] =
  147. {
  148.    {&PreludeName,    "PR"}
  149. };
  150. */
  151.  
  152.  
  153. /*
  154.     Initialise "save" values for preferences to be the
  155.     original value for those preferences.
  156. */
  157.  
  158. InitPrefs()
  159. {
  160.   int i;
  161.   for(i=0;i < sizeof(Prefs)/sizeof(struct Prefs); ++i)
  162.     Prefs[i].savevalue = Prefs[i].setvalue;
  163. }
  164.  
  165. /*
  166.     Save the user's preferences.  Preferences are saved in the
  167.     same file that they were taken from, so preferences in the
  168.     startup directory are overwritten before system-wide preferences.
  169. */
  170.  
  171. SavePrefs()
  172. {
  173.   int i;
  174.   FILE *prefs;
  175.   char buff[256];
  176.   
  177.   OSErr resultcode;
  178.  
  179.   /* If the preference volume is unset, locate it */
  180.   if(!prefsvolset)
  181.     {
  182.        resultcode = FindFolder(kOnSystemDisk, kPreferencesFolderType, kCreateFolder, 
  183.                                &prefsvolref, &prefsdirID);
  184.  
  185.        if (resultcode != noErr)
  186.         {
  187.           Error("I/O ","Can't find Preferences folder");
  188.           return;
  189.         }
  190.       else
  191.         prefsvolset = TRUE;
  192.     }
  193.  
  194.   resultcode = hcreate(PrefsName,prefsvolref,prefsdirID,creator,preftype);
  195.  
  196.   if ( (resultcode != noErr) && (resultcode != dupFNErr) )
  197.     {
  198.        Error("I/O ","Can't create Preferences file");
  199.        return;
  200.     }
  201.  
  202.   (void) HSetVol(NIL,prefsvolref,prefsdirID);
  203.  
  204.   /* Now write to the preferences file proper */   
  205.   if((prefs = fopen(PrefsName,"w"))==NULL)
  206.     Error("I/O ","Can't write to Preferences file");
  207.  
  208.   else
  209.     {
  210.       for(i=0;i < sizeof(Prefs)/sizeof(struct Prefs); ++i)
  211.         {
  212.           sprintf(buff,"%s: %d\n",Prefs[i].tag,*(Prefs[i].savevalue));
  213.       fputc(strlen(buff),prefs);
  214.       fputs(buff,prefs);
  215.     }     
  216.  
  217.       for(i=0;i < sizeof(BPrefs)/sizeof(struct BPrefs); ++i)
  218.         {
  219.           sprintf(buff,"%s: %d\n",BPrefs[i].tag,*(BPrefs[i].value)?TRUE:FALSE);
  220.       fputc(strlen(buff),prefs);
  221.       fputs(buff,prefs);
  222.     }
  223.  
  224. #if 0
  225.       for(i=0;i < sizeof(SPrefs)/sizeof(struct SPrefs); ++i)
  226.         {
  227.           sprintf(buff,"%s: %s\n",SPrefs[i].tag,*(SPrefs[i].value));
  228.       fputc(strlen(buff),prefs);
  229.       fputs(buff,prefs);
  230.     }
  231. #endif
  232.  
  233.       fclose(prefs);
  234.       FlushVol(NIL,prefsvolref);
  235.       HiddenPrefsChanged = FALSE;
  236.     }
  237.   resetdir();
  238. }
  239.  
  240.  
  241.  
  242. /*
  243.     Restore the user's preferences file.  Preference is given to the
  244.     file in the startup folder, or failing that to the one in the
  245.     Preferences folder.
  246. */
  247.  
  248. RestorePrefs(toggles)
  249. int toggles;
  250. {
  251.   if(checkFileExists(PrefsName,preludevolref,preludedirID))
  252.     {
  253.       dorestoreprefs(PrefsName,preludevolref,preludedirID,toggles);
  254.       prefsvolref = preludevolref;
  255.       prefsdirID =  preludedirID;
  256.       prefsvolset = TRUE;
  257.     }
  258.   else
  259.     {
  260.        if (FindFolder(kOnSystemDisk,kPreferencesFolderType,
  261.                       kCreateFolder,&prefsvolref,&prefsdirID) == noErr)
  262.       { 
  263.         if(checkFileExists(PrefsName,prefsvolref,prefsdirID))
  264.           dorestoreprefs(PrefsName,prefsvolref,prefsdirID,toggles);
  265.         prefsvolset = TRUE;
  266.       }
  267.      }
  268. }
  269.  
  270.  
  271. int restoreintpref(tag,ival)
  272. char *tag;
  273. int ival;
  274. {
  275.   int i;
  276.  
  277.   if(!HiddenPrefsChanged)
  278.     for(i=0; i < sizeof(Prefs)/sizeof(struct Prefs); ++i)
  279.       if(strcmp(tag,Prefs[i].tag)==0)
  280.         {
  281.           *(Prefs[i].setvalue) = *(Prefs[i].savevalue) = ival;
  282.           return(TRUE);
  283.         }
  284.   return(FALSE);
  285. }
  286.  
  287. int restoreboolpref(tag,ival)
  288. char *tag;
  289. int ival;
  290. {
  291.   int i;
  292.  
  293.   for(i=0; i < sizeof(BPrefs)/sizeof(struct BPrefs); ++i)
  294.     if(strcmp(tag,BPrefs[i].tag)==0)
  295.       {
  296.         if(HiddenPrefsChanged && BPrefs[i].HiddenPref)
  297.       return(FALSE);
  298.     else
  299.       {
  300.             *(BPrefs[i].value) = ival? TRUE: FALSE;
  301.             return(TRUE);
  302.       }
  303.       }
  304.   return(FALSE);
  305. }
  306.  
  307.  
  308.  
  309. int restorestringpref(tag,value)
  310. char *tag, *value;
  311. {
  312. #if 0
  313.   int i;
  314.  
  315.   for(i=0; i < sizeof(SPrefs)/sizeof(struct SPrefs); ++i)
  316.     if(strcmp(tag,SPrefs[i].tag)==0)
  317.       {
  318.         *(SPrefs[i].value) = safemalloc(strlen(value)+1);
  319.         strcpy(*(SPrefs[i].value),value);
  320.         return(TRUE);
  321.       }
  322. #endif
  323.   return(FALSE);
  324. }
  325.  
  326.  
  327. /*
  328.     Restore a preference from a line.
  329. */
  330.  
  331. restorepref(pref,toggles)
  332. char pref[];
  333. int toggles;
  334. {
  335.   char tag[256], strval[256];
  336.   int i=0, j=0, ival;
  337.   
  338.   while(pref[j] != '\0' && pref[j] != ':')
  339.     tag[i++] = pref[j++];
  340.   tag[i] = '\0';
  341.   
  342.   if(pref[j]==':')
  343.     j++;
  344.  
  345.   while(isspace(pref[j]))
  346.     j++;
  347.  
  348.   i = 0; 
  349.   while(pref[j] != '\0' && pref[j] != '\n')
  350.     strval[i++] = pref[j++];
  351.   strval[i] = '\0';
  352.  
  353.   ival = atoi(strval);
  354.   
  355.   if(!restoreintpref(tag,ival))
  356.     if(!(toggles && restoreboolpref(tag,ival)))
  357.       restorestringpref(tag,strval);
  358. }
  359.  
  360.  
  361. /*
  362.     Save the hidden preferences, e.g. those set in memory or
  363.     arcana dialogs.
  364. */
  365.  
  366. SaveHiddenPrefs()
  367. {
  368.   if(HiddenPrefsChanged)
  369.     {
  370.       /* Restore non-hidden preferences to saved state, then save all */
  371.       RestorePrefs(TRUE);
  372.       SavePrefs();
  373.     }
  374. }
  375.  
  376.  
  377.